/**
 * Microi吾码 低代码平台 前端uni-app开发包：microi.uniapp.js
 * v1.1
 * 【初始化】：
 * 1、【非H5发行无需此步】 在index.html <head> 中添加全局变量，用于docker环境变量替换
 * 注意每行格式需要要一模一样，【var ApiBase = '';】不能去掉空格写成【var ApiBase='';】
 * 	<script type="text/javascript">
		var ApiBase = '';
		var OsClient = '';
		var FileServer = '';
	</script>
 * 2、在main.js引用：import Microi from "./common/microi.uniapp.js"
 * 	全局Microi对象赋值vue2：Vue.prototype.Microi = Microi
 * 	全局Microi对象赋值vue3：app.config.globalProperties.Microi = Microi
 * 3、在App.vue onLaunch中执行：this.Microi.Init();//集成了获取系统设置、自动登录、Token定时以旧换新 等等
 * 
 * 【常用】：
 * 接口请求（Get请求同理）：
 * 	异步：self.Microi.Post('/api/ApiEngine/sysuser_reg', { Account : 'test' }, function(result){ ... })
 * 	同步：var result = await self.Microi.Post('/api/ApiEngine/sysuser_reg', { Account : 'test' })
 * 
 * 表单引擎 FormEngine（AddFormData、UptFormData等等同理，完整用法见平台文档[FormEngine用法]，前/后端、PC/移动端用法均保持一致）：
 * 	异步：self.Microi.FormEngine.GetFormData({ FormEngineKey : '', Id : '' }, function(result){ ... })
 * 	同步：var result = await self.Microi.FormEngine.GetFormData({ FormEngineKey : '', Id : '' })
 * 
 * 接口引擎 ApiEngine（ModuleEngine同理）：
 * 	异步：self.Microi.ApiEngine.Run('sysuser_reg', { Account : 'test' }, function(result){ ... })
 * 	同步：var result = await self.Microi.ApiEngine.Run('sysuser_reg', { Account : 'test' })
 * 
 * 【常用函数】：
 *	Microi.IsLogin()//判断当前是否是已登录状态，已登录返回true
 * 	Microi.GetToken() //获取当前token值
 * 	Microi.GetCurrentUser() //获取当前登录身份信息
 * 	Microi.Tips('操作成功') //成功提示
 * 	Microi.Tips('操作失败', false) //失败提示
 *	new Date().Format('yyyy-MM-dd') //日期格式化。类似函数：AddTime、DiffTime
 * 	Microi.RouterPush('path', true/false) //页面跳转，第二个参数默认false，为true会判断当前是否登录状态，未登录则直接跳转到登录页面。
 * 
 * 备注：后期需实现所有提示文字使用多语言。
 */
/**
 * 是否显示常用的console.log信息
 */
var ConsoleLog = true;
/**
 * 修复非H5发行全局变量访问报错
 */
try{
	if(ApiBase){}
}catch(e){
	var ApiBase = ''; var OsClient = ''; var FileServer = ''; var TenantId = ''; var Weburl = '';
}
/**
 * 全局Microi对象
 */
var Microi = { 
	ApiBase: ApiBase || 'https://api.nbweixin.cn', //接口前缀，前端写死
	Weburl: Weburl || 'https://ximushe.nbweixin.cn', //OsClient值，前端写死
	OsClient: OsClient || 'ximushe', //OsClient值，前端写死
	TenantId: TenantId || 'a300566c-f4f3-46a9-8f70-b504d1af7199', 
	FileServer : FileServer || 'https://minio.nbweixin.cn/public', //自动从SysConfig系统设置中获取，前端无需写死
	ConsoleLog : ConsoleLog, //是否显示常用的console.log信息
	Api: {
		GetSysConfig : '/api/DiyTable/getSysConfig',//获取系统设置，此接口后端会走缓存
		Login : '/api/SysUser/login',//用户登录
		AddFormData : '/api/FormEngine/addFormData',//添加一条数据
		/**
		 * 批量添加数据，后端带事务
		 */
		AddFormDataBatch : '/api/FormEngine/addFormDataBatch',
		DelFormData : '/api/FormEngine/delFormData',//删除一条数据
		DelFormDataBatch : '/api/FormEngine/delFormDataBatch',//批量删除数据，后端带事务
		DelFormDataByWhere : '/api/FormEngine/delFormDataByWhere',//根据条件批量删除数据，慎用
		UptFormData : '/api/FormEngine/uptFormData',//修改一条数据
		UptFormDataBatch : '/api/FormEngine/uptFormDataBatch',//批量修改数据，后端带事务
		UptFormDataByWhere : '/api/FormEngine/uptFormDataByWhere',//根据条件批量修改数据，慎用
		GetFormData : '/api/FormEngine/getFormData',//获取一条数据
		GetTableData : '/api/FormEngine/getTableData',//获取列表数据
		ApiEngineRun : '/api/ApiEngine/run',//执行接口引擎
		ModuleEngineRun : '/api/ModuleEngineRun/run',//执行模块引擎
		RefreshToken : '/api/SysUser/refreshToken',//token以旧换新
		RefreshLoginUser : '/api/SysUser/refreshLoginUser',//更新当前登陆用户身份信息
		Upload : '/api/HDFS/upload',//上传文件、图片
		UploadAnonymous : '/api/HDFS/uploadAnonymous',//上传文件、图片
		UniappUpload : '/api/HDFS/uniappUpload',//上传文件、图片
		UniappUploadAnonymous : '/api/HDFS/uniappUploadAnonymous',//上传文件、图片
		GetCurrentUser : '/api/SysUser/GetCurrentUser',//获取当前登录身份信息
		GetFormDataAnonymous : '/api/FormEngine/GetFormDataAnonymous',//获取列表数据
		GetTableDataAnonymous : '/api/FormEngine/GetTableDataAnonymous',//获取列表数据
		GetDateTimeNow : '/api/os/getDateTimeNow',//获取服务器当前时间
		AddSysLog : '/api/SysLog/addSysLog',//添加日志
	},
	/**
	 * 平台初始化
	 * 1、获取SysConfig系统设置信息
	 * 2、自动登录
	 * 3、定时获取获取登录身份信息
	 */
	Init: async function(param){
		try {
			//强制获取系统设置
			await Microi.GetSysConfig(true);
			//自动登录（token以旧换新）
			await Microi.RefreshToken(param && param.TokenCallback);
			//从后端获取当前登录用户身份信息
			Microi.GetCurrentUser(true, param && param.TokenCallback);
			//每1分钟前端检查一次token是否快到期
			setInterval(function(){
				Microi.RefreshToken(param && param.TokenCallback);
			}, 1000 * 60)
			//每5分钟从后端获取当前登录用户身份信息
			setInterval(function(){
				Microi.GetCurrentUser(true, param && param.TokenCallback)
			}, 1000 * 60 * 5)
			//获取服务器时间
			Microi.InitDateTimeNow();
		} catch (e) {
		  Microi.Tips('系统初始化失败：' + (e.message || e.Msg), false)
		  !ConsoleLog || console.log('Microi：系统初始化失败：' + (e.message || e.Msg))
		}
	},
	/**
	 * 异步获取系统设置信息，需使用await
	 * @param {Object} refresh 是否强制重新从服务器获取并刷新缓存
	 */
	GetSysConfig: async function(refresh){
		if(!refresh){
			var sysConfigStr = uni.getStorageSync("SysConfig");
			if(sysConfigStr){
				return JSON.parse(sysConfigStr);
			}
		}
		var getSysConfigResult = await Microi.Post(Microi.ApiBase + Microi.Api.GetSysConfig, {
			OsClient : Microi.OsClient,
			_SearchEqual : {
				IsEnable : 1
			}
		}, null, {
			DataType : 'form'
		});
		if(!getSysConfigResult.Code){
			Microi.Tips('获取系统设置失败：' + getSysConfigResult.Msg);
			!ConsoleLog || console.log('Microi：获取系统设置失败：', getSysConfigResult.Msg);
			return null;
		}
		var getSysConfig = getSysConfigResult.Data;
		if(getSysConfig.FileServer){
			Microi.FileServer = getSysConfig.FileServer;
		}
		//!ConsoleLog || console.log('Microi：获取系统设置信息成功：', getSysConfig);
		uni.setStorageSync('SysConfig', JSON.stringify(getSysConfig));
		return getSysConfig;
	},
	InitDateTimeTimer : null,
	InitDateTimeNow: function(){
		Microi.Post(Microi.ApiBase + Microi.Api.GetDateTimeNow, {}, function(result){
			if(result.Code){
				Microi.DateTimeNow = new Date(result.Data);
				try{
					clearInterval(Microi.InitDateTimeTimer)
				}catch(e){}
				Microi.InitDateTimeTimer = setInterval(function(){
					Microi.DateTimeNow = Microi.DateTimeNow.AddTime('s', 1);
				}, 1000)
			}
		});
		
	},
	/**
	 * 同步获取系统设置信息
	 */
	GetSysConfigSync: function(){
		var sysConfigStr = uni.getStorageSync("SysConfig");
		if(sysConfigStr){
			return JSON.parse(sysConfigStr);
		}
		return null;
	},
	RefreshLoginUser: async function(){
		var result = await Microi.Post(Microi.ApiBase + Microi.Api.RefreshLoginUser);
		// if(Microi.CheckResult(result)){
		if(result.Code){
			Microi.SetCurrentUser(result.Data);
		}
		return result;
	},
	/**
	 * token以旧换新
	 */
	RefreshToken: async function(){
		//获取token 或身份信息，判断登录自动
		var token = Microi.GetToken();
		var currentUser = Microi.GetCurrentUser();
		//如果存在token，判断是否已过期
		if (token) {
			var expires = uni.getStorageSync("TokenExpires");
			//如果已过期，或不存在登录身份信息，则使用token以旧换新
			if(!expires || !currentUser || new Date() >= new Date(expires)){
				var result = await Microi.Post(Microi.ApiBase + Microi.Api.RefreshToken, {
					authorization : token
				});
				if(result.Code){
					Microi.SetCurrentUser(result.Data);
				}else{
					//如果已经超过18分钟，将身份信息置空
					if(!expires || new Date().DiffTime('m', new Date(expires)) < 2){
						Microi.SetCurrentUser('');
					}
					!ConsoleLog || console.log('Microi：Token以旧换新失败：' + result.Msg)
					return { Code : 0, Msg : 'Token以旧换新失败：' + result.Msg };
				}
			}
		}else{
			!ConsoleLog || console.log('Microi：Token以旧换新失败：不存在旧的token！')
			return { Code : 0, Msg : 'Token以旧换新失败：不存在旧的token！' };
		}
	},
	/**
	 * 表单引擎
	 */
	FormEngine : {
		/**
		 * 新增简洁用法：Microi.AddFormData('sys_user', { Name : '', Account : '' }, function(){ ... })
		 */
		AddFormData : async function(paramOrFormEngineKey, formDataOrCallback, callback){
			var realParam = {
				FormEngineKey : '',
				Id : '',
				_RowModel : {},
			};
			var realCallback;
			if(typeof(param) == 'string'){
				realParam.FormEngineKey = paramOrFormEngineKey;
				if(!formDataOrCallback){
					formDataOrCallback = {};
				}
				for(let key in formDataOrCallback){
					if(key == 'Id'){
						realParam.Id = formDataOrCallback[key]
					}else{
						realParam._RowModel[key] = formDataOrCallback[key];
					}
				}
				realCallback = callback;
			}else{
				realParam = paramOrFormEngineKey;
				realCallback = formDataOrCallback;
			}
			// if(param._Where){
			// 	param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			// }else{
			// 	param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			// }
			// realParam._RowModel.TenantId = Microi.TenantId;
			var result = await Microi.Post(Microi.Api.AddFormData, realParam, realCallback);
			return result;
		},
		AddFormDataBatch : async function(param, callback){
			// if(param._Where){
			// 	param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			// }else{
			// 	param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			// }
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.AddFormDataBatch, param, callback);
			return result;
		},
		DelFormData : async function(param, callback){
			// if(param._Where){
			// 	param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			// }else{
			// 	param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			// }
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.DelFormData, param, callback);
			return result;
		},
		DelFormDataBatch : async function(param, callback){
			// if(param._Where){
			// 	param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			// }else{
			// 	param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			// }
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.DelFormDataBatch, param, callback);
			return result;
		},
		DelFormDataByWhere : async function(param, callback){
			if(param._Where){
				param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			}else{
				param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			}
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.DelFormDataByWhere, param, callback);
			return result;
		},
		UptFormData : async function(param, callback){
			var result = await Microi.Post(Microi.Api.UptFormData, param, callback);
			return result;
		},
		UptFormDataByWhere : async function(param, callback){
			if(param._Where){
				param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			}else{
				param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			}
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.UptFormDataByWhere, param, callback);
			return result;
		},
		UptFormDataBatch : async function(param, callback){
			if(param._Where){
				param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			}else{
				param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			}
			var result = await Microi.Post(Microi.Api.UptFormDataBatch, param, callback);
			return result;
		},
		GetFormData : async function(param, callback){
			// if(param._Where){
			// 	param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			// }else{
			// 	param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			// }
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.GetFormData, param, callback);
			return result;
		},
		GetTableData : async function(param, callback){
			// if(param._Where){
			// 	param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			// }else{
			// 	param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			// }
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.GetTableData, param, callback);
			return result;
		},
		GetFormDataAnonymous : async function(param, callback){
			if(param._Where){
				param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			}else{
				param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			}
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.GetFormDataAnonymous, param, callback);
			return result;
		},
		GetTableDataAnonymous : async function(param, callback){
			if(param._Where){
				param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			}else{
				param._Where = [{Name:'TenantId',Value: Microi.TenantId, Type: '='}]
			}
			// param._Where.push({Name:'TenantId',Value: Microi.TenantId, Type: '='});
			var result = await Microi.Post(Microi.Api.GetTableDataAnonymous, param, callback);
			return result;
		},
		
	},
	/**
	 * 接口引擎
	 */
    ApiEngine : {
		/**
		 * @param {Object} urlOrOption url 或 option
		 * @param {Object} dataOrCallback data 或 callback回调函数
		 * @param {Object} callback callback回调函数
		 */
    	Run : async function(urlOrOption, dataOrCallback, callback){
    		if(typeof(urlOrOption) == 'string'){
				//如果是这种模式：.Run('ApiEngineKey', {}, function(){})
				var apiKey = urlOrOption.toString();
				var param = {};
				param.ApiEngineKey = apiKey;
				param.TenantId = Microi.TenantId;
				for (let key in dataOrCallback) {
					param[key] = dataOrCallback[key];
				}
				var result = await Microi.Post('/api/ApiEngine/run', param, callback, { IsApiEngine : true });
				return result;
			}else{
				//如果是这种模式：.Run({}, function(){})
				var result = await Microi.Post('/api/ApiEngine/run', dataOrCallback);
				return result;
			}
    	},
    },
	/**
	 * 模块引擎
	 */
	ModuleEngine : {
		/**
		 * @param {Object} urlOrOption url 或 option
		 * @param {Object} dataOrCallback data 或 callback回调函数
		 * @param {Object} callback callback回调函数
		 */
		Run : async function(urlOrOption, dataOrCallback, callback){
			if(typeof(urlOrOption) == 'string'){
				//如果是这种模式：.Run('ModuleEngineKey', {}, function(){})
				var apiKey = urlOrOption.toString();
				var param = {};
				param.ModuleEngineKey = apiKey;
				for (let key in dataOrCallback) {
					param[key] = dataOrCallback[key];
				}
				var result = await Microi.Post('/api/ModuleEngine/run', param, callback);
				return result;
			}else{
				//如果是这种模式：.Run({}, function(){})
				var result = await Microi.Post('/api/ModuleEngine/run', dataOrCallback);
				return result;
			}
		},
	},
    /**
	 * 同步获取当前用户登录身份信息
     */
	GetCurrentUser: function(refresh){
		if(refresh){
			Microi.Post(Microi.ApiBase + Microi.Api.GetCurrentUser, {}, function(result){
				if(result.Code){
					Microi.SetCurrentUser(result.Data);
				}
			});
		}
		var currentUserStr = uni.getStorageSync("CurrentUser");
		if(currentUserStr && typeof currentUserStr == 'string'){
			return JSON.parse(currentUserStr);
		}else if (currentUserStr){
			return currentUserStr
		}
		return null;
	},
	/**
	 * 同步设置当前登录身份信息
	 */
	SetCurrentUser: function(currentUser){
		if(typeof(currentUser) == 'string'){
			uni.setStorageSync("CurrentUser", currentUser);
		}else{
			uni.setStorageSync("CurrentUser", JSON.stringify(currentUser));
		}
	},
	/**
	 * 同步获取当前token值
	 */
	GetToken: function(){
		return uni.getStorageSync("Token");
	},
	/**
	 * 同步设置当前token值，同时设置过期时间为15分钟后（服务器为20分钟，最后5分钟会以旧换新）
	 * @param {Object} token
	 */
	SetToken: function(token){
		uni.setStorageSync("Token", token);
		if(!token){
			uni.setStorageSync("TokenExpires", '');
		}else{
			uni.setStorageSync("TokenExpires", new Date().AddTime('m', 15).Format('yyyy-MM-dd HH:mm:ss'));
		}
	},
	/**
	 * 用户登录。传入Account、Pwd、
	 * @param {Object} param
	 */
	Login: async function(param){
		var result = await Microi.Post(Microi.Api.Login, param, null, {
			DataType : 'form'
		});
		if(result.Code){
			Microi.SetCurrentUser(result.Data);
		}else{
			Microi.Tips('登录失败：' + result.Msg, false);
		}
		return result;
	},
	Logout: function(){
		Microi.SetToken('');
		Microi.SetCurrentUser('');
		uni.setStorageSync("HuodongID", '');
		uni.setStorageSync("ShangjiID", '');
	},
	/**
	 * 提示
	 * @param {Object} text 提示内容
	 * @param {Object} isSuccess 是否成功，默认true
	 * @param {Object} time 持续时间，单位毫秒，默认1000，isSuccess为false时默认5000
	 */
	Tips: function(text, isSuccess, time) {
		if(isSuccess == undefined || isSuccess == null){
			isSuccess = true;
		}
		uni.showToast({
			title: text || "出错啦~",
			icon: isSuccess ? 'none' : 'none',
			duration: time || (isSuccess ? 1000 : 5000)
		})
	},
	
	/**
	 * 
	 * @param {Object} title
	 * @param {Object} content
	 * @param {Object} showCancel
	 * @param {Object} callback
	 * @param {Object} confirmColor
	 * @param {Object} confirmText
	 */
	Modal: function(title, content, showCancel, callback, confirmColor, confirmText) {
		uni.showModal({
			title: title || '提示',
			content: content,
			showCancel: showCancel,
			cancelColor: "#555",
			confirmColor: confirmColor || "#5677fc",
			confirmText: confirmText || "确定",
			success(res) {
				if (res.confirm) {
					callback && callback(true)
				} else {
					callback && callback(false)
				}
			}
		})
	},
	/**
	 * 
	 */
	IsAndroid: function() {
		const res = uni.getSystemInfoSync();
		return res.platform.toLocaleLowerCase() == "android"
	},
	/**
	 * 
	 */
	IsPhoneX: function() {
		const res = uni.getSystemInfoSync();
		let iphonex = false;
		let models = ['iphonex', 'iphonexr', 'iphonexsmax', 'iphone11', 'iphone11pro', 'iphone11promax']
		const model = res.model.replace(/\s/g, "").toLowerCase()
		if (models.includes(model)) {
			iphonex = true;
		}
		return iphonex;
	},
	/**
	 * 
	 */
	Loading: function(title, mask = true) {
		uni.showLoading({
			mask: mask,
			title: title || '请稍候...'
		})
	},
	/**
	 * Post请求
	 * @param {Object} url
	 * @param {Object} data
	 * @param {Object} callback
	 * @param {Object} option
	 */
	Post: async function(url, data, callback, option){
		var fullUrl = url.startsWith('http') ? url : Microi.ApiBase + url;
		var result = await Microi.request({
			...option,
			Url : url,
			Data : data,
		});
		if(callback){
			callback(result);
		}
		return result;
	},
	/**
	 * Get请求
	 * @param {Object} url
	 * @param {Object} data
	 * @param {Object} callback
	 * @param {Object} option
	 */
	Get: async function(url, data, callback, option){
		var fullUrl = url.startsWith('http') ? url : Microi.ApiBase + url;
		var result = await Microi.request({
			...option,
			Url : url,
			Data : data,
			Method : 'GET'
		});
		if(callback){
			callback(result);
		}
		return result;
	},
	/**
	 * 接口请求
	 * Url：接口地址
	 * Method：默认post，可选get
	 * Data：参数
	 * DataType：默认json，可选form
	 * IsApiEngine：是否接口引擎接口，默认false
	 * Header：
	 */
	request: async function(param) {
		param.TenantId = Microi.TenantId;
		var { Url, Method, Data, DataType, IsApiEngine, Header } = param;
		if(!DataType){
			DataType = 'json';
		}
		if(!Data){
			Data = {};
		}
		var clientType = 'H5';//H5、WeChat、Android、IOS
		// #ifdef APP-PLUS
		clientType = 'Android'
		// #endif
		// #ifdef MP-WEIXIN
		clientType = 'WeChat'
		// #endif
		Data._ClientType = clientType;
		Data.OsClient = Microi.OsClient;
		var fullUrl = Url.startsWith('http') ? Url : Microi.ApiBase + Url;
		var header = {
					'content-type': DataType.toLowerCase() != 'form' ? 'application/json' : 'application/x-www-form-urlencoded',
					authorization: 'Bearer ' + Microi.GetToken(),
					osclient: Microi.OsClient,
					clienttype : clientType,
					apiengine : IsApiEngine || 0,
				};
		if(Header){
			for (let key in Header) {
				header[key] = Header[key];
			}
		}
		return new Promise((resolve, reject) => {
			uni.request({
				url: fullUrl,
				data: Data,
				header: header,
				method: Method || 'POST',
				dataType: DataType || 'json',
				success: (res) => {
					let token = res.header.Authorization || res.header.authorization
					if(token){
						Microi.SetToken(token)
					}
					var result = res.data;
					try{
						var resultObj = JSON.parse(result);
						resolve(resultObj)
					}catch(e){
						resolve(result)
					}
				},
				fail: (res) => {
					Microi.Tips("网络出现问题，请重试：" + res.msg)
					!ConsoleLog || console.log('Microi：request fail 网络出现问题，请重试：', res)
					reject({
						Code : 0, Data: res, Msg : res.msg
					})
				}
			})
		})
	},
	/**
	 * 检查接口返回结果，若有错误则做出提示
	 * @param {Object} result
	 */
	CheckResult: function(result){
		if(!result || typeof(result) != 'object'){
			return false;
		}else if(result.Code != 1){
			Microi.Tips('操作失败：' + result.Msg, false)
			return false;
		}
		return true;
	},
	//判断是否登录
	IsLogin: function() {
		var currentUser = Microi.GetCurrentUser() ? true : false
		var token = Microi.GetToken() ? true : false
		if(!currentUser || !token){
			return false;
		}
		return true;
	},
	CheckLogin: function() {
		if(!Microi.IsLogin()){
			Microi.Tips('请先登录~', false);
			setTimeout(function(){
				uni.reLaunch({
					url: '/pages/tabbar/my/my'
				})
			},600);
			return;
		}
	},
	/**
	 * 跳转页面，可判断是否登录
	 * @param {Object} url
	 * @param {Object} isVerify 校验登录状态
	 */
	RouterPush(url, isVerify) {
		if (isVerify && !Microi.IsLogin()) {
			uni.navigateTo({
				url: '/pages/common/login/login'
			})
		} else {
			uni.navigateTo({
				url: url
			});
		}
	},
	navigateBack(){
		let pages = getCurrentPages(); //获取所有页面栈实例列表
		let prevPage = pages[pages.length - 2]; //上一页页面实例
		//prevPage.$vm.AddressId = Id; //修改上一页data里面的index参数值
		uni.navigateBack({   // 返回上一页面
			delta: 1   // 返回的页面数
		});
	},
	/**
	 * 上传文件、图片
	 * Path：文件路径前缀，如：/img、/file
	 * Limit：是否上传到私有存储桶，默认false
	 * Preview：是否压缩图片，默认false
	 * _FilePath：前端图片地址，格式如：blob:http://localhost:5173/bf13a4fc-ea0d-4994-83b3-f07393878e14
	 * _UseUniappUpload：默认false
	 * _Anonymous：默认false
	 */
	Upload: async function(param, callback) {
		if(!param || !param._FilePath){
			Microi.Tips('前端参数错误！', false);
			return { Code : 0, Msg : '前端参数错误！' };
		}
		var clientType = 'H5';//H5、WeChat、Android、IOS
		// #ifdef APP-PLUS
		clientType = 'Android'
		// #endif
		// #ifdef MP-WEIXIN
		clientType = 'WeChat'
		// #endif
		param._ClientType = clientType;
		param.OsClient = Microi.OsClient;
		
		param.Preview = "false";
		var header = {
					// 'content-type': DataType.toLowerCase() != 'form' ? 'application/json' : 'application/x-www-form-urlencoded',
					authorization: 'Bearer ' + Microi.GetToken(),
					osclient: Microi.OsClient,
					clienttype : clientType,
					// apiengine : IsApiEngine || 0,
				};
		var uploadUrl = Microi.ApiBase + Microi.Api.Upload;
		if(param._UseUniappUpload){
			if(!param._Anonymous){
				uploadUrl = Microi.ApiBase + Microi.Api.UniappUpload;
			}else{
				uploadUrl = Microi.ApiBase + Microi.Api.UniappUploadAnonymous;
			}
		}else if(param._Anonymous){
			uploadUrl = Microi.ApiBase + Microi.Api.UploadAnonymous;
		}
		// Microi.Loading('上传中', false)
		return new Promise((resolve, reject) => {
			const uploadTask = uni.uploadFile({
				url: uploadUrl,
				filePath: param._FilePath,
				name: 'imageFile',
				header: {
					...header
				},
				formData: {
					...param,
					// sizeArrayText:""
				},
				success: function(res) {
					var result = res.data;
					try{
						result = JSON.parse(res.data);
					}catch(e){}
					if(callback){
						callback(result);
					}
					resolve(result)
					// uni.hideLoading()
					// let d = JSON.parse(res.data.replace(/\ufeff/g, "") || "{}")
					// if (d.code % 100 == 0) {
					// 	//返回图片地址
					// 	let fileObj = d.data;
					// 	resolve(fileObj)
					// } else {
					// 	that.toast(res.msg);
					// }
				},
				fail: function(res) {
					if(callback){
						callback({ Code : 0 , Data : res, Msg : res.msg });
					}
					reject({ Code : 0 , Data : res, Msg : res.msg })
					// that.toast(res.msg);
				}
			})
		})
	},
	UploadAnonymous: async function(param, callback) {
		param._Anonymous = true;
		return await Microi.Upload(param, callback);
	}
}
/**
 * 日期格式化
 * 用法：new Date().Format('yyyy-MM-dd HH:mm:ss')
 * @param {Object} format
 */
Date.prototype.Format = function(format) {
  if (!format) {
    return this
  }
  var o = {
    'M+': this.getMonth() + 1, // month
    'd+': this.getDate(), // day
    'h+': this.getHours(), // hour
    'H+': this.getHours(), // hour
    'm+': this.getMinutes(), // minute
    's+': this.getSeconds(), // second
    'q+': Math.floor((this.getMonth() + 3) / 3), // quarter
    'S': this.getMilliseconds() // millisecond
  }
  if (/(y+)/.test(format)) {
    format = format.replace(RegExp.$1,
      (this.getFullYear() + '').substr(4 - RegExp.$1.length))
  }
  for (var k in o) {
    if (new RegExp('(' + k + ')').test(format)) {
      format = format.replace(RegExp.$1,
        RegExp.$1.length == 1 ? o[k]
          : ('00' + o[k]).substr(('' + o[k]).length))
    }
  }
  return format
}
/**
 * 日期增加
 * 用法：new Date().AddTime('m', 15) //增加15分钟
 * @param {Object} unit 单位：s（秒）、m（分）、h（时）、d（天）、w（周）、q（季）、M（月）、y（年）
 * @param {Object} number 时长
 */
Date.prototype.AddTime = function(unit, number) {
  var dtTmp = this
  switch (unit) {
    //秒
    case 's':
      return new Date(Date.parse(dtTmp) + (1000 * number))
    //分
    case 'n':
      return new Date(Date.parse(dtTmp) + (60000 * number))
    //分
    case 'm':
      return new Date(Date.parse(dtTmp) + (60000 * number))
    //小时
    case 'h':
      return new Date(Date.parse(dtTmp) + (3600000 * number))
    //小时
    case 'H':
      return new Date(Date.parse(dtTmp) + (3600000 * number))
    //天
    case 'd':
      return new Date(Date.parse(dtTmp) + (86400000 * number))
    //周
    case 'w':
      return new Date(Date.parse(dtTmp) + ((86400000 * 7) * number))
    //季
    case 'q':
      return new Date(dtTmp.getFullYear(), (dtTmp.getMonth()) + number * 3, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds())
    //月
    case 'M':
      return new Date(dtTmp.getFullYear(), (dtTmp.getMonth()) + number, dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds())
    //年
    case 'y':
      return new Date((dtTmp.getFullYear() + number), dtTmp.getMonth(), dtTmp.getDate(), dtTmp.getHours(), dtTmp.getMinutes(), dtTmp.getSeconds())
  }
  return null
}
/**
 * 计算时间差。time2大于前者时，返回正数，反之返回负数。
 * @param {Object} unit 单位：s（秒）、m（分）、h（时）、d（天）、w（周）、q（季）、M（月）、y（年）
 * @param {Object} time2 time2大于前者时，返回正数，反之返回负数。
 */
Date.prototype.DiffTime = function(unit, time2) {
  var d = this
  var i = {}
  var t = d.getTime()
  var t2 = time2.getTime()
  i['y'] = time2.getFullYear() - d.getFullYear()
  i['q'] = i['y'] * 4 + Math.floor(time2.getMonth() / 4) - Math.floor(d.getMonth() / 4)
  i['M'] = i['y'] * 12 + time2.getMonth() - d.getMonth()
  i['ms'] = time2.getTime() - d.getTime()
  i['w'] = Math.floor((t2 + 345600000) / (604800000)) - Math.floor((t + 345600000) / (604800000))
  i['d'] = Math.floor(t2 / 86400000) - Math.floor(t / 86400000)
  i['h'] = Math.floor(t2 / 3600000) - Math.floor(t / 3600000)
  i['H'] = Math.floor(t2 / 3600000) - Math.floor(t / 3600000)
  i['m'] = Math.floor(t2 / 60000) - Math.floor(t / 60000)
  i['s'] = Math.floor(t2 / 1000) - Math.floor(t / 1000)
  return i[unit]
}
export default Microi